﻿#define _CRT_SECURE_NO_WARNINGS 1
////#include "test.h"
////#include <stdio.h>
////#include <iostream>
////#include <map>
////#include <vector>
////#include <string>
////using namespace std;
////vector<string> uncommonFromSentences(string s1, string s2) {
////    map<string, int> dic1;
////    vector<string> v;
////    string ret1;
////    for (int i = 0; i < s1.size(); i++)
////    {
////        if (s1[i] == ' ')
////        {
////            dic1[ret1]++;
////            ret1.clear();
////        }
////        else
////            ret1 += s1[i];
////    }
////    string ret2;
////    map<string, int> dic2;
////    for (int i = 0; i < s2.size(); i++)
////    {
////        if (s2[i] == ' ')
////        {
////            dic2[ret2]++;
////            ret2.clear();
////        }
////        else
////            ret2 += s2[i];
////    }
////    for (auto& ch : dic1)
////    {
////        if (ch.second == 1 && dic2[ch.first] == 0)
////            v.push_back(ch.first);
////    }
////    for (auto& ch : dic2)
////    {
////        if (ch.second == 1 && dic1[ch.first] == 0)
////            v.push_back(ch.first);
////    }
////
////    return v;
////}
////int main()
////{
////
////    string s1 = "this apple is sweet", s2 = "this apple is sour";
////    uncommonFromSentences(s1, s2);
////
////	return 0;
////}
//
//
////#include <iostream>
////#include <map>
////using namespace std;
////int main()
////{
////   /* map<int, int> mp;
////    int n;
////    cin >> n;
////    for (int i = 0; i < n; i++)
////    {
////        int x, c;
////        cin >> x >> c;
////        mp[x] += c;
////    }
////    int m;
////    cin >> m;
////    for (int i = 0; i < m; i++)
////    {
////        int l, r;
////        cin >> l >> r;
////        int ret = 0;
////        for (auto& n : mp)
////        {
////            if (n.first >= l && n.first <= r)ret += n.second;
////        }
////        cout << ret << endl;
////    }*/
////    cout << 2e5;
////    return 0;
////}
//
//
////#include<iostream>
////#include <vector>
////using  namespace std;
////const int N = 20;
////typedef pair<int, int> PII;
////vector<vector<int>>maze;
////vector<PII> path;
////vector<PII> minpath;
////int n, m;
////
////void dfs(int x, int y)//不可进入n+1,m+1类型，所以要在达到目的时直接判断并得出结果。
////{
////    if (x == n-1 && y == m-1)
////    {
////        cout << "hello";
////        path.push_back({ x,y });
////        if (minpath.empty() || (path.size() < minpath.size()))
////            minpath = path;
////    }
////
////
////    if (x + 1 < n && maze[x + 1][y] == 0)
////    {
////        path.push_back({ x,y });
////        maze[x][y] = 1;
////        dfs(x + 1, y);
////        maze[x][y] = 0;
////        path.pop_back();
////    }
////
////
////
////    if (x - 1 >= 0 && maze[x - 1][y] == 0)
////    {
////        path.push_back({ x,y });
////        maze[x][y] = 1;
////        dfs(x - 1, y);
////        maze[x][y] = 0;
////        path.pop_back();
////    }
////
////
////    if (y + 1 < m && maze[x][y + 1] == 0)
////    {
////        path.push_back({ x,y });
////        maze[x][y] = 1;
////        dfs(x, y + 1);
////        maze[x][y] = 0;
////        path.pop_back();
////    }
////
////    if (y - 1 >= 0 && maze[x][y - 1] == 0)
////    {
////        path.push_back({ x,y });
////        maze[x][y] = 1;
////        dfs(x, y - 1);
////        maze[x][y] = 0;
////        path.pop_back();
////    }
////}
////int main()
////{
////    while (cin >> n >> m)
////    {
////        maze = vector<vector<int>>(n, vector<int>(m, 0));
////        for (int i = 0; i < n; i++)
////        {
////            for (int j = 0; j < m; j++)
////            {
////                cin >> maze[i][j];
////            }
////        }
////        dfs(0, 0);
////        for (int i = 0; i < minpath.size(); i++)cout << '(' << minpath[i].first << ',' << minpath[i].second << ')' << endl;
////    }
////
////    return 0;
////}
//
//
////
////#include <iostream>
////#include <string>
////#include <vector>
////#include <map>
////using namespace std;
////vector<string> commonChars(vector<string>& words) {
////    map<int, int> dic;
////    vector<string> ret;
////    int cnt = 1;
////    for (int i = 0; i < words.size(); i++)
////    {
////        cnt = 0;//单词中出现的重复的第cnt+1个。重复的单词可以相同可以不同，反正重复的就往后移动找位置存
////        for (int j = 0; j < words[i].size(); j++)
////        {
////            if (dic[words[i][j]] == i + 1)
////            {
////                cnt++;
////                dic[words[i][j] + 26 * cnt]++;
////            }
////            else dic[words[i][j]]++;
////        }
////    }
////    for (auto& n : dic)
////    {
////        if (n.second == words.size())
////        {
////            int tmp= n.first;
////            while (tmp > 'z' || tmp < 'a')tmp-= 26;
////            char ch = tmp;
////            string s1;
////            s1 += (ch);
////            ret.push_back(s1);
////        }
////    }
////
////    return ret;
////}
////
////int main()
////{
////    ////vector<string> v = { "acabcddd","bcbdbcbd","baddbadb","cbdddcac","aacbcccd","ccccddda","cababaab","addcaccd" };
////    ////vector<string>ret=commonChars(v);
////    ////for (int i = 0; i < ret.size(); i++)cout << ret[i] << ' ';
////    //int a[5] = { 1,2,3,4,5 };
////    //memset(a, 0, 5*sizeof(a[0]));
////    //for (int i = 0; i < 5; i++)cout << a[i] << ' ';
////    cout << 1 % 0;
////    return 0;
////}
////#include <iostream>
////#include <vector>
////#include <map>
////using namespace std;
////
////bool st[10000];
////vector<int> path;
////vector<vector<int>>ret;
////int sum = 0;
////void dfs(int idex, int target, vector<int>& q)
////{
////    if (sum > target)return;
////    if (sum == target)ret.push_back(path);
////    for (int i = idex; i < q.size(); i++)
////    {
////
////        st[q[i]] = true;
////        sum += q[i];
////        path.push_back(q[i]);
////        dfs(i + 1, target, q);
////        path.pop_back();
////        sum -= q[i];
////        st[q[i]] = false;;
////
////    }
////}
////vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
////    dfs(0, target, candidates);
////
////    
////    for (int i = 0; i < ret.size(); i++)
////    {
////        for (int j = i + 1; j < ret.size(); j++)
////        {
////            map<int, int> dic1, dic2;
////            for (int k = 0; k < ret[i].size(); k++)
////            {
////                dic1[ret[i][k]]++;
////            }
////            for (int b = 0; b < ret[j].size(); b++)
////            {
////                dic2[ret[j][b]]++;
////            }
////            int flag = 1;
////            for (auto& n : dic1)
////            {
////                if (n.second != dic2[n.first])flag = 0;
////            }
////            if (flag)
////            {
////                auto it = ret.begin();
////                it = ret.erase(it + j);
////            }
////        }
////    }
////    return ret;
////}
////int main()
////{
////    /*vector<int> v = { 2,2,2 };
////    combinationSum2(v, 2);*/
////    cout << ((void*)-1) << endl;
////
////    return 0;
////}
//
//
//#include <iostream>
//#include <vector>
//#include <string>
//using namespace std;
//vector<string>  result;
//string path;
//string str;
//bool isValid(const string& s, int start, int end) {
//    if (start > end) {
//        return false;
//    }
//    if (s[start] == '0' && start != end) { // 0开头的数字不合法
//        return false;
//    }
//    int num = 0;
//    num = stoi(s.substr(start, end - start + 1));
//    if (num > 255)
//    {
//        cout << num<<endl;
//        return false;
//    }
//    for (int i = start; i <= end; i++) {
//        if (s[i] > '9' || s[i] < '0') { // 遇到⾮数字字符不合法
//            return false;
//        }
//        num = num * 10 + (s[i] - '0');
//        if (num > 255) { // 如果⼤于255了不合法
//            return false;
//        }
//    }
//    return true;
//}
//void backtracking(string& s, int startIndex, int pointNum) {
//    //确保是正确的地址
//    if (pointNum == 3) { // 逗点数量为3时，分隔结束
//        // 判断第四段⼦字符串是否合法，如果合法就放进result中
//        if (isValid(s, startIndex, s.size() - 1)) {
//            result.push_back(s);
//        }
//        return;
//    }
//    for (int i = startIndex; i < s.size(); i++) {
//        if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的⼦串是否合法
//            s.insert(s.begin() + i + 1, '.');  // 在i的后⾯插⼊⼀个逗点
//            pointNum++;
//            backtracking(s, i + 2, pointNum);   // 插⼊逗点之后下⼀个⼦串的起始位置为i+2
//            pointNum--;                         // 回溯
//            s.erase(s.begin() + i + 1);         // 回溯删掉逗点
//        }
//        else break; // 不合法，直接结束本层循环
//    }
//}
//// 判断字符串s在左闭⼜闭区间[start, end]所组成的数字是否合法
//vector<string> restoreIpAddresses(string s) {
//    result.clear();
//    if (s.size() > 12) return result; // 算是剪枝了        
//    backtracking(s, 0, 0);
//    return result;
//}
//typedef pair<int, int> PII;
//vector<PII> path;
//vector<int> vval(100, 0);
//vector<int> vsort(100, 0);
//vector<vector<int>>ret;
//
//
//bool used[10000];
//bool isincrease(vector<int> v)
//{
//    int i = 0, j = 1;
//    while (i < v.size() && j < v.size())
//    {
//        if (v[i] > v[j])return false;
//
//        i++, j++;
//    }
//    return true;
//}
//void dfs(vector<PII>& v, int idex)
//{
//    if (path.size() >= 2)
//    {
//        for (int i = 0; i < path.size(); i++)
//        {
//            vval = path[i].first;
//            vsort = path[i].second;
//        }
//        if (isincrease(val) && isincrease(vsort))
//        {
//            ret.push_back(path);
//        }
//    }
//    for (int i = idex; i < mp.size(); i++)
//    {
//        if (i > 0 && v[i - 1].first == v[i].first && used[i - 1] == false)
//        {
//            continue;
//        }
//
//        path.push_back(nums[i]);
//        used[i] = true;
//        dfs(v, i + 1);
//        path.pop_back();
//        used[i] = false;
//    }
//}
//vector<vector<int>> findSubsequences(vector<int>& nums) {
//    vector<PII> v;
//    for (int i = 0; i < nums.size(); i++)
//    {
//        v[i].first = nums[i], v[i].second = i;
//    }
//    sort(v.begin(), v.end());
//    dfs(v, 0);
//    return ret;
//}
//int main()
//{
//    vector<vector<int>> v(10, vector<int>(2, 1));
//    for (int i = 0; i < 10; i++)
//    {
//        for (int j = 0; j < 2; j++)cout << v[i][j];
//        cout << endl;
//    }
//    vector<int> val(10, 2);
//    for (int i = 0; i < val.size(); i++)cout << val[i] << endl;
//   /* string s = "25525511135";
//    restoreIpAddresses(s);*/
//    return 0;
//}

//
//#include <iostream>
//#include <vector>
//#include <algorithm>
//using namespace std;
//typedef pair<int, int> PII;
//vector<PII> path;
//vector<int> vval;
//vector<int> vsort;
//vector<vector<int>>ret;
//
//
//bool used[10000];
//bool isincrease(vector<int> v)
//{
//    int i = 0, j = 1;
//    while (i < v.size() && j < v.size())
//    {
//        if (v[i] > v[j])return false;
//
//        i++, j++;
//    }
//    return true;
//}
//void dfs(vector<PII>& v, int idex)
//{
//    if (path.size() >= 2)
//    {
//        for (int i = 0; i < path.size(); i++)
//        {
//            vval.clear();
//            vsort.clear();
//            vval.push_back(path[i].first);
//            vsort.push_back(path[i].second);
//        }
//        if (isincrease(vval) && isincrease(vsort))
//        {
//            ret.push_back(vval);
//        }
//    }
//    for (int i = idex; i < v.size(); i++)
//    {
//        if (i > 0 && v[i - 1].first == v[i].first && used[i - 1] == false)
//        {
//            continue;
//        }
//
//        path.push_back(v[i]);
//        used[i] = true;
//        dfs(v, i + 1);
//        path.pop_back();
//        used[i] = false;
//    }
//}
//vector<vector<int>> findSubsequences(vector<int>& nums) {
//    vector<PII> v;
//    for (int i = 0; i < nums.size(); i++)
//    {
//        v.push_back(PII());
//        v[i].first = nums[i], v[i].second = i;
//    }
//    sort(v.begin(), v.end());
//    dfs(v, 0);
//    return ret;
//}
//int main()
//{
//    vector<int> nums = { 4,6,7,7 };
//    findSubsequences(nums);
//    for (int i = 0; i < ret.size(); i++)
//    {
//        for (int j = 0; j < ret[i].size(); i++)cout << ret[i][j] << ' ';
//        cout << endl;
//    }
//	return 0;
//}


//#include <iostream>
//#include <time.h>
//using namespace std;
//struct A { int a[10000]; };
//void TestFunc1(A a) {}
//void TestFunc2(A& a) {}
//void TestRefAndValue()
//{
//    A a;
//    // 以值作为函数参数
//    size_t begin1 = clock();
//    for (size_t i = 0; i < 10000; ++i)
//        TestFunc1(a);
//    size_t end1 = clock();
//    // 以引用作为函数参数
//    size_t begin2 = clock();
//    for (size_t i = 0; i < 10000; ++i)
//        TestFunc2(a);
//    size_t end2 = clock();
//    // 分别计算两个函数运行结束后的时间
//    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
//    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
//}
//int main()
//{
//    TestRefAndValue();
//    return 0;
//}

//
//#include <iostream>
//#include <time.h>
//using namespace std;
//struct Date
//{
//private:
//    int day_ = 0;
//    int month = 0;
//    int year_ = 0;
//};
//Date func1()
//{
//    return Date();
//}
//const Date& func2()
//{
//    return Date();
//}
//void test()
//{
//    size_t begin1 = clock();
//    for(int i=0;i<10000;i++)
//    func1();
//    size_t end1 = clock();
//
//    size_t begin2 = clock();
//    for(int i=0;i<10000;i++)
//    func2();
//    size_t end2 = clock();
//
//    cout << "time-Date:" << begin1 - end1<<endl;
//    cout << "time-Date&:" << begin2 - end2 << end1;
//
//}
//int main()
//{
//    test();
//    return 0;
//}


//#include <iostream>
//#include <time.h>
//using namespace std;
//struct A{ int a[10000]; };
//A a;
//// 值返回
//A TestFunc1() { return a; }// 引用返回
//A& TestFunc2() { return a; }
//void TestReturnByRefOrValue() {
//    // 以值作为函数的返回值类型
//    size_t begin1=clock();
//    for (size_t i = 0; i < 100000; ++i)
//        TestFunc1();
//    size_t end1 = clock();
//    // 以引用作为函数的返回值类型
//    size_t begin2 = clock();
//    for (size_t i = 0; i < 100000; ++i)
//        TestFunc2();
//    size_t end2 = clock();
//    // 计算两个函数运算完成之后的时间
//    cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl;
//}
//int main()
//{
//    TestReturnByRefOrValue();
//    return 0;
//}


//#include <iostream>
//using namespace std;
//int main()
//{
//    int a = 10;
//    int& ra = a;//语法上，只是给a取了个别名，没有开空间
//
//    a++;
//    cout << "&a = " << &a << endl;//stdout 11
//    a++;
//    cout << "&ra = " << &ra << endl;//stdout 12
//
//
//    int b = 10;
//    int* pb = &b;//语法上，给pb开了空间（32位下开4字节，64位下开8字节），用于存储b的地址
//
//    b++;
//    cout << "b = " << b << endl;//stdout 11
//    b++;
//    cout << "*pb = " << *pb << endl;//stdout 12
//    return 0;
//}



//#include <iostream>
//using namespace std;
//int  Add1(int left, int right)
//{
//	return left + right;
//}
//inline int Add2(int left, int right)
//{
//	return left + right;
//}
//int main()
//{
//
//	cout << Add1(1, 2) << endl;
//	cout << Add2(2, 3) << endl;
//
//	return 0;
//}


//#include <iostream>
//using namespace std;
//int main()
//{
//	int arr[5] = { 0 };
//	for (auto& e : arr)cout << e << endl;
//	NULL;
//	nullptr;
//	return 0;
//}






//#include <iostream>
//using namespace std;
//
//class A
//{
//public:
//	int a;
//	void funA()
//	{
//		cout << "i am A" << endl;
//	}
//};
//
//
//class B :public A
//{
//public:
//	int b=1;
//	void funB()
//	{
//		cout << "i am B" << endl;
//	}
//};
//
//int main()
//{
//	B b;
//	A a = b;
//	return 0;
//}

//
//
//#include <iostream>
//#include <vector>
//using namespace std;
//
//const int N = 1e5;
//int C[N];
//void add1(int A[], int A_sz, int B[], int B_sz, int* C_sz)
//{
//	if (A_sz < B_sz) return add1(B, B_sz, A, A_sz, C_sz);
//
//
//
//	int t = 0;
//	for (int i = 0; i < A_sz; i++)
//	{
//		t += A[i];
//		if (i < B_sz) t += B[i];
//		C[(*C_sz)++] = t % 10;
//		t /= 10;
//	}
//	if (t)C[*(C_sz)++] = t;
//}
//
//
//int test()
//{
//	int A[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
//	int B[] = {0,0,0,0,0,0,0,0,3,0,4,5,6,7,8,9,9,0,2,3,3,4,5,6,9,9,9,9,9};
//	int A_sz = sizeof(A) / sizeof(A[0]);
//	int B_sz = sizeof(B) / sizeof(B[0]);
//	int C_sz = 0;
//	add1(A, A_sz, B, B_sz,&C_sz);
//	for (int i = C_sz ; i >= 0; i--)cout << C[i]<<' ';
//    cout << endl;
//	cout << A_sz << ' ' << B_sz << ' ' << C_sz;
//
//	return 0;
//}
//
//
//
//vector<int> add(vector<int>& A, vector<int>& B)
//{
//    if (A.size() < B.size()) return add(B, A);
//
//    vector<int> C;
//    int t = 0;
//    for (int i = 0; i < A.size(); i++)
//    {
//        t += A[i];//用于求和:如果大于0则进位再加到ret数组中，不大于0则直接加到ret数组中
//        //如果t<10，则push_back()的直接就是t,如果t>=10,则push_back的是t%10，到最后t%10，进位给高位
//        if (i < B.size()) t += B[i];
//        C.push_back(t % 10);
//        t /= 10;
//    }
//
//    if (t) C.push_back(t);
//    return C;
//}
//int main()
//{
//    test();
//    cout << endl;
//    vector<int> A = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 };
//    vector<int> B= { 0,0,0,0,0,0,0,0,3,0,4,5,6,7,8,9,9,0,2,3,3,4,5,6,9,9,9,9,9 };
//    vector<int> C = add(A, B);
//    for (int i = C.size() - 1; i >= 0; i--)cout << C[i]<<' ';
//    cout << endl;
//    cout << A.size() << ' ' << B.size() << ' ' << C.size();
//    return 0;
//}
//
//
//#include <iostream>
//#include <cstdio>
//using namespace std;
//const int N = 1e5 + 10;
//int a[N][N];
//int s1[N][N];
//int main()
//{
//    int n, m, q;
//    cin >> n >> m >> q;
//    for (int i = 1; i <= n; i++)
//    {
//        for (int j = 1; j <= m; j++)
//            scanf("%d", &a[i][j]);
//    }
//
//    for (int i = 1; i <= n; i++)
//    {
//        for (int j = 1; j <= m; j++)
//        {
//            s1[i][j] = s1[i - 1][j] + s1[i][j - 1] - s1[i - 1][j - 1] + a[i][j];
//        }
//    }
//
//    while (q--)
//    {
//        int x1, y1, x2, y2;
//        cin >> x1 >> y1 >> x2 >> y2;
//        cout << s1[x2][y2] - s1[x1 - 1][y2] - s1[x2][y1 - 1] + s1[x1 - 1][y1 - 1] << endl;
//    }
//
//    return 0;
//}


//#include <iostream>
//#include <cstdio>
//using namespace std;
//const int N = 1e3;
//char a[N];
//int main()
//{
//    int n;
//    scanf("%d", &n);
//
//    scanf("%s", a);
//
//    if (n <= 1)
//    {
//        for (int i = 0; i < n; i++)cout << a[i] << ' ';
//        return 0;
//    }
//
//    int fastidex = 0, slowidex = 0;
//    int cnt = 0;
//    int ret = 0;
//    for (; fastidex < n; fastidex++)
//    {
//        if (a[fastidex] != a[slowidex]||a[fastidex]!='x')cnt = 0, slowidex = fastidex;
//        if (a[slowidex] == 'x'&&a[fastidex] == a[slowidex])cnt++;
//        while (a[slowidex] == 'x'&&cnt >= 3)slowidex++, cnt--, ret++;
//    }
//    cout << ret;
//    return 0;
//}






//
//n个砖块排成一排，从左到右编号依次为 1∼n。
//
//每个砖块要么是黑色的，要么是白色的。
//
//现在你可以进行以下操作若干次（可以是 0次）：
//
//选择两个相邻的砖块，反转它们的颜色。（黑变白，白变黑）
//
//你的目标是通过不超过 3n次操作，将所有砖块的颜色变得一致。
//


//#include <iostream>
//#include <cstdio>
//using namespace std;
//const int N = 1e5 + 10;
//int a[N], b[N];
//
//int main()
//{
//    int n, m, x;
//    cin >> n >> m >> x;
//    for (int i = 0; i < n; i++)scanf("%d", &a[i]);
//    for (int i = 0; i < m; i++)scanf("%d", &b[i]);
//    int l = 0, r = m - 1;
//    while (l < n && r >= 0)
//    {
//        while (r >= 0 && l < n && a[l] + b[r] >x)r--;
//        while (r >= 0 && l < n && a[l] + b[r] <x)l++;
//
//        if (l < n && r >= 0 && a[l] + b[r] == x)
//        {
//            cout << l << ' ' << r << endl;
//            return 0;
//        }
//    }
//    cout << -1 << ' ' << -1;
//
//
//    return 0;
//}



//#include <iostream>
//#include <cstdio>
//#include <time.h>
//using namespace std;
//const int N = 1e5 + 10;
//int a[N], b[N];
//
//int main()
//{
//    int n, m, x;
//    cin >> n >> m >> x;
//    for (int i = 0; i < n; i++)scanf("%d", &a[i]);
//    for (int i = 0; i < m; i++)scanf("%d", &b[i]);
//    int l = 0, r = m - 1;
//
//    int begin = clock()*100000;
//    while (l < n && r >= 0)
//    {
//        while (r >= 0 && l < n && a[l] + b[r] >x)r--;
//        while (r >= 0 && l < n && a[l] + b[r] < x)l++;
//
//        if (l < n && r >= 0 && a[l] + b[r] == x)
//        {
//            cout << l << ' ' << r << endl;
//            break;
//        }
//    }
//    int end = clock()*100000;
//    printf("%d", end - begin);
//
// 
//    return 0;
//}




#include <iostream>
//using namespace std;
//class A
//{
//public:
//    static int a;
//};
//int A::a = 10;
//int main()
//{
//    A* a1 = new A;
//    A* a2 = new A;
//    A* a3 = new A;
//    A* a4 = new A;
// 
//
//    cout << a1->a<<endl;//stdout 10
//    a1->a--;
//    delete a1;
//    cout << a2->a<<endl;//stdout 9
//    a2->a--;
//    delete a2;
//    cout << a3->a<<endl;//stdout 8
//    a3->a--;
//    delete a3;
//    cout << a4->a<<endl;//stdout 7
//    return 0;
//}





//#include <iostream>
//using namespace std;
//// 类中既有成员变量，又有成员函数
//class A1
//{
//public:
//    void f1() {}
//private:
//    int _a;
//};
//
//// 类中仅有成员函数
//class A2
//{
//public:
//    void f2() {}
//};
//
//// 类中什么都没有---空类
//class A3
//{};
//
//int main()
//{
//    cout << sizeof(A1) << endl;//
//    cout << sizeof(A2) << endl;
//    cout << sizeof(A3) << endl;
//    return 0;
//}





#include <iostream>
using namespace std;

//void func1(Date* a);
//
//class Date
//{
//public:
//    void Init(int year, int month, int day)
//    {
//        _year = year;
//        _month = month;
//        _day = day;
//
//    }
//
//    void PrintDate()
//    {
//        cout << _year << '-' << _month << '-' << _day << endl;
//        func1(this);
//    }
//private:
//    int _year;//年
//    int _month;//月
//    int _day;//日
//    int a;
//
//   
//};
//
//void func1(Date* a)
//{
//    a->PrintDate();
//}
//
//int main()
//{
//    Date d1, d2;
//    d1.Init(2023,2, 23);
//    d2.Init(2023, 1, 12);
//    d1.PrintDate();
//    d2.PrintDate();
//    return 0;
//}
//class Date
//{
//public:
//    void Init(int year, int month, int day)
//    {
//        _year = year;
//        _month = month;
//        _day = day;
//    }
//
//    void PrintDate(Date* const this)
//    {
//        cout << _year << '-' << _month << '-' << _day << endl;
//        cout << this->_year << ' ' << this->_month << ' ' << this->_day << endl;
//    }
//
//
//
//private:
//    int _year;//年
//    int _month;//月
//    int _day;//日
//    int a;
//
//
//};
//
//void Init(Date* const this, int year, int month, int day)
//{
//    this = nullptr;//不能这样改，因为const指针修饰了，但是内容可以改
//    this->_year = year;
//    this->_month = month;
//    this->_day = day;
//}
//void PrintDate(Date* const this)
//{
//    cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
//}
//
//int main()
//{
//    Date d1;
//    d1.Init(&d1, 2022, 9, 27);
//    Date d2;
//    d2.Init(&d2, 2022, 9, 28);
//    d1.PrintDate(&d1);
//    d2.PrintDate(&d2);
//    return 0;
//}




//#include <iostream>
//#include <queue>
//#include <vector>
//#include <algorithm>
//using namespace std;
//template<class T>
//class Less
//{
//public:
//	bool operator()(const T& l, const T& r)
//	{
//		return l < r;
//	}
//};
//int main()
//{
//	int a[] = { 1,3,4,5,6,4,2,5,8 };
//	int sz = sizeof(a) / sizeof(a[0]);
//	vector<int> v= { 1,3,4,5,6,4,2,5,8 };
//	sort(v.begin(), v.end(), Less<int>());
//	for (int i = 0; i < v.size(); i++)cout << v[i] << ' ';
//
//	cout << endl;
//
//	priority_queue<int>q;//默认为less<int>,升序 
//	//priority只有无参构造(默认less)、 迭代器区间+comp构造 和 迭代器区间构造(默认less)
//	for (auto& n : v)q.push(n);
//	for (auto& n : v)
//	{
//		cout << q.top() << ' ';
//		q.pop();
//	}
//
//
//
//	return 0;
//}